home *** CD-ROM | disk | FTP | other *** search
/ Aminet 15 / Aminet 15 - Nov 1996.iso / Aminet / dev / c / EasygadgetsSou.lha / EasyGadgets / Requesters.c < prev    next >
C/C++ Source or Header  |  1995-11-09  |  10KB  |  455 lines
  1. /*
  2.  *    File:                    Requesters.c
  3.  *    Description:    A more friendly front to EasyRequest and DisplayAlert
  4.  *
  5.  *    (C) 1994, Ketil Hunn
  6.  *
  7.  */
  8.  
  9. #ifndef EG_REQUESTERS_H
  10. #define EG_REQUESTERS_H
  11.  
  12. __asm __saveds LONG egDisplayAlert(    register __d0 ULONG alertType,
  13.                                                                         register __a0 UBYTE *msg,
  14.                                                                         register __d1    ULONG timeout)
  15. {
  16.     register    LONG    result=-1;
  17.     register    char    *alertMsg;
  18.                         int        size=StrLen(msg)+500;
  19.  
  20. #ifdef MYDEBUG_H
  21.     DebugOut("egDisplayAlert");
  22. #endif
  23.  
  24.     if(alertMsg=AllocVec(size, MEMF_CLEAR))
  25.     {
  26.         register    UBYTE    *c;
  27.         register    BYTE    ypos=14;
  28.         register    UBYTE    *line, *nextline;
  29.         register    int        length;
  30.         register    BOOL    done=FALSE;
  31.  
  32.         c=alertMsg;
  33.         line=msg;
  34.         while(!done)
  35.         {
  36.             nextline=StrChr(line, '\n');
  37.             if(nextline==NULL)
  38.                 done=TRUE;
  39.             else
  40.             {
  41.                 *nextline='\0';
  42.                 ++nextline;
  43.             }
  44.             length=(80-StrLen(line))<<2;
  45.             *c++=length / 0x100;
  46.             *c++=length & 0x0FF;
  47.             *c++=ypos;
  48.             while(*line!='\0')
  49.                 *c++=*line++;
  50.             *c++=0;
  51.             *c++=1;
  52.             ypos+=11;
  53.             line=nextline;
  54.         }
  55.         *(c-1)=0;
  56.         if(timeout>0 && IntuitionBase->LibNode.lib_Version>38)
  57.             result=TimedDisplayAlert(alertType, alertMsg, ypos, timeout);
  58.         else
  59.             result=DisplayAlert(alertType, alertMsg, ypos);
  60.  
  61.         FreeVec(alertMsg);
  62.     }
  63.     return result;
  64. }
  65.  
  66. __asm __saveds LONG egRequestA(    register __a0 struct Window *window,
  67.                                                                 register __a1 UBYTE                    *title,
  68.                                                                 register __a2 UBYTE                    *format,
  69.                                                                 register __a4 UBYTE                    *gadgets,
  70.                                                                 register __a3 APTR                     *args)
  71. {
  72.     struct EasyStruct myES;
  73.  
  74. #ifdef MYDEBUG_H
  75.     DebugOut("egRequestA");
  76. #endif
  77.  
  78.     myES.es_StructSize        =sizeof(struct EasyStruct);
  79.     myES.es_Title                    =title;
  80.     myES.es_TextFormat        =format;
  81.     myES.es_GadgetFormat    =gadgets;
  82.  
  83.     return EasyRequestArgs(window, &myES, NULL, args);
  84. }
  85.  
  86. /*
  87. __asm void egGetRequesterTags(register __d0 unsigned long reqType,
  88.                                                             register __a1 APTR req,
  89.                                                             register __a0 struct TagItem *taglist)
  90. {
  91.     struct ListviewRequester    *lvreq=(struct ListviewRequester *)req;
  92.     struct TagItem *tstate;
  93.     struct TagItem *tag;
  94.  
  95. #ifdef MYDEBUG_H
  96.     DebugOut("egGetRequesterTags");
  97. #endif
  98.  
  99.         tstate=taglist;
  100.         while(tag=NextTagItem(&tstate))
  101.             switch(tag->ti_Tag)
  102.             {
  103.                 case WA_Window:
  104.                     lvreq->pwindow=(struct Window *)tag->ti_Data;
  105.                     if(lvreq->pwindow)
  106.                         lvreq->task.screen    =lvreq->pwindow->WScreen;
  107.                     break;
  108.                 case WA_Screen:
  109.                     lvreq->task.screen=(struct Screen *)tag->ti_Data;
  110.                     break;
  111.                 case EG_InitialLeftEdge:
  112.                     lvreq->LeftEdge    =(WORD)tag->ti_Data;
  113.                     break;
  114.                 case EG_InitialTopEdge:
  115.                     lvreq->TopEdge    =(WORD)tag->ti_Data;
  116.                     break;
  117.                 case EG_InitialWidth:
  118.                     lvreq->Width    =(WORD)tag->ti_Data;
  119.                     break;
  120.                 case EG_InitialHeight:
  121.                     lvreq->Height    =(WORD)tag->ti_Data;
  122.                     break;
  123.                 case EG_InitialPercentV:
  124.                     lvreq->percentv    =(BOOL)tag->ti_Data;
  125.                     break;
  126.                 case EG_InitialPercentH:
  127.                     lvreq->percenth    =(BOOL)tag->ti_Data;
  128.                     break;
  129.                 case EG_InitialCentreH:
  130.                     lvreq->centreh=    (BOOL)tag->ti_Data;
  131.                     break;
  132.                 case EG_InitialCentreV:
  133.                     lvreq->centrev=    (BOOL)tag->ti_Data;
  134.                     break;
  135.                 case EG_TitleText:
  136.                     if(lvreq->titletext)
  137.                         Free(lvreq->titletext);
  138.                     lvreq->titletext=StrDup((UBYTE *)tag->ti_Data);
  139.                     break;
  140.                 case EG_CloseGadget:
  141.                     lvreq->closegadget=    (BOOL)tag->ti_Data;
  142.                     break;
  143.                 case EG_SizeGadget:
  144.                     lvreq->sizegadget=    (BOOL)tag->ti_Data;
  145.                     break;
  146.                 case EG_TextAttr:
  147.                     egSetReqFont(lvreq, (struct TextAttr *)tag->ti_Data);
  148.                     break;
  149.                 case EG_SameGadgetWidth:
  150.                     lvreq->samegadgetwidth=    (BOOL)tag->ti_Data;
  151.                     break;
  152.                 case EG_SimpleRefresh:
  153.                     lvreq->simplerefresh=    (BOOL)tag->ti_Data;
  154.                     break;
  155.                 case EG_Gadgets:
  156.                     if(lvreq->numgads)
  157.                     {
  158.                         register ULONG i;
  159.  
  160.                         for(i=0; i<lvreq->numgads; i++)
  161.                             Free(lvreq->gadgettexts->text[i]);
  162.                         FreeVec(lvreq->gadgettexts);
  163.                         lvreq->numgads=0;
  164.                     }
  165.                     egParseGadgetString(lvreq, (UBYTE *)tag->ti_Data);
  166.                     break;
  167.                 case EG_SleepWindow:
  168.                     lvreq->sleepwindow=    (BOOL)tag->ti_Data;
  169.                     break;
  170.                 case EG_PrivateIDCMP:
  171.                     lvreq->privateidcmp=    (BOOL)tag->ti_Data;
  172.                     break;
  173.                 case EG_IntuiMsgFunc:
  174.                     lvreq->func=(void *)tag->ti_Data;
  175.                     break;
  176.                 case EG_UserData:
  177.                     lvreq->eg_UserData    =(APTR)tag->ti_Data;
  178.                     break;
  179.             }
  180.  
  181.         switch(lvreq->type)
  182.         {
  183.             case EG_ListviewRequest:
  184.                 tstate=taglist;
  185.                 while(tag=NextTagItem(&tstate))
  186.                     switch(tag->ti_Tag)
  187.                     {
  188.                         case EGLV_Labels:
  189.                             lvreq->list    =(struct List *)tag->ti_Data;
  190.                             break;
  191.                         case EGLV_Selected:
  192.                             lvreq->selectednum    =(LONG)tag->ti_Data;
  193.                             break;
  194.                         case EGLV_ReadOnly:
  195.                             lvreq->readonly=    (BOOL)tag->ti_Data;
  196.                             break;
  197.                         case EGLV_DropDown:
  198.                             lvreq->dropdown=    (BOOL)tag->ti_Data;
  199.                             break;
  200.                     }
  201.                 break;
  202.         }
  203. }
  204.  
  205. __asm __saveds APTR egAllocRequestA(register __d0 unsigned long reqType,
  206.                                                                         register __a0 struct TagItem *taglist)
  207. {
  208.     register struct ListviewRequester        *req=NULL;
  209.  
  210. #ifdef MYDEBUG_H
  211.     DebugOut("egAllocRequestA");
  212. #endif
  213.  
  214.     switch(reqType)
  215.     {
  216.         case EG_ListviewRequest:
  217.             req=(struct ListviewRequester *)AllocVec(sizeof(struct ListviewRequester), MEMF_CLEAR|MEMF_PUBLIC);
  218.             egGetRequesterTags(EG_ListviewRequest, req, taglist);
  219.             break;
  220.     }
  221.  
  222.     if(req!=NULL)
  223.     {
  224.         if(req->task.screen==NULL && req->pwindow)
  225.             req->task.screen=req->pwindow->WScreen;
  226.  
  227.         if(req->task.screen==NULL)
  228.         {
  229.             struct Screen *wbscreen;
  230.  
  231.             if(wbscreen=LockPubScreen(NULL))
  232.             {
  233.                 req->task.screen=wbscreen;
  234.                 UnlockPubScreen(NULL, wbscreen);
  235.             }
  236.         }
  237.  
  238. //        if(req->font==NULL)
  239. //            mrSetReqFont(req, NULL);
  240.  
  241.         if(req->titletext==NULL)
  242.             req->titletext=StrDup(EG_DefTitleText);
  243.  
  244.         req->type=reqType;
  245.  
  246.         switch(reqType)
  247.         {
  248.             case EG_ListviewRequest:
  249.                 {
  250. //                    register struct ListviewRequester    *lvreq=(struct ListviewRequester *)req;
  251. //                    lvreq->IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library", 37L);
  252.                     return (struct ListviewRequester *)req;
  253.                 }
  254.                 break;
  255.         }    
  256.     }
  257.  
  258.     return NULL;
  259. }
  260.  
  261. __asm __saveds void egFreeRequest(register __a0 APTR req)
  262. {
  263. #ifdef MYDEBUG_H
  264.     DebugOut("egFreeRequest");
  265. #endif
  266.  
  267.     if(req)
  268.     {
  269.         struct ListviewRequester    *tmpreq=(struct ListviewRequester *)req;
  270.         register ULONG i;
  271.  
  272.         Free(tmpreq->titletext);
  273.  
  274.         for(i=0; i<tmpreq->numgads; i++)
  275.             Free(tmpreq->gadgettexts[i]);
  276.         FreeVec(tmpreq->gadgettexts);
  277.  
  278.         CloseFont(tmpreq->font);
  279.  
  280.         switch(tmpreq->type)
  281.         {
  282.             case EG_ListviewRequest:
  283.                 break;
  284.         }
  285.         FreeVec(tmpreq);
  286.     }
  287. }
  288.  
  289. __asm void egParseGadgetString(    register __a0 APTR req,
  290.                                                                 register __a1 UBYTE *string)
  291. {
  292.     register struct ListviewRequester    *lvreq=(struct ListviewRequester *)req;
  293.     register UBYTE *text, *t, *c;
  294.     register ULONG numgads;
  295.  
  296. #ifdef MYDEBUG_H
  297.     DebugOut("egParseGadgetString");
  298. #endif
  299.  
  300.     if(string!=NULL)
  301.     {
  302.         numgads=1L;
  303.  
  304.         if(text=t=StrDup(string))
  305.         {
  306.             while(*t!='\0')
  307.             {
  308.                 if(*t=='|')
  309.                     numgads++;
  310.                 t++;
  311.             }
  312.             lvreq->numgads=numgads;
  313.  
  314.             if(lvreq->gadgettexts=AllocVec(2*sizeof(UBYTE *)*(numgads+1), MEMF_CLEAR))
  315.             {
  316.                 register ULONG i=0;
  317.                 t=text;
  318.                 while(*t!='\0')
  319.                 {
  320.                     c=t;
  321.                     while(*t!='|' && *t!='\0')
  322.                         t++;
  323.  
  324.                     if(*t!='\0')
  325.                         *t++='\0';
  326.  
  327.                     lvreq->gadgettexts[i++]=StrDup(c);
  328.                 }
  329.             }
  330.             Free(text);
  331.         }
  332.     }
  333.     else
  334.         lvreq->numgads=0;
  335. }
  336.  
  337. __asm void egCloseRequester(register __a0 APTR inreq)
  338. {
  339.     register struct ListviewRequester *req=(struct ListviewRequester *)inreq;
  340.     register struct Window    *win=req->window;
  341.  
  342. #ifdef MYDEBUG_H
  343.     DebugOut("egCloseRequester");
  344. #endif
  345. //    RemoveGList(win, req->glist, -1);
  346.  
  347.     req->LeftEdge    =win->LeftEdge;
  348.     req->TopEdge    =win->TopEdge;
  349.     req->Width        =win->Width-win->BorderLeft-win->BorderRight;
  350.     req->Height        =win->Height-win->BorderTop-win->BorderBottom;
  351.  
  352.     mrCloseWindowSafely(win);
  353.     FreeGadgets(req->glist);
  354.     req->window=NULL;
  355. }
  356.  
  357. __asm __saveds UWORD egRequestA(register __a1 APTR req,
  358.                                                                 register __a0 struct TagItem *taglist)
  359. {
  360.     struct ListviewRequester *lvreq=(struct ListviewRequester *)req;
  361.     UWORD retvalue=0;
  362.  
  363. #ifdef MYDEBUG_H
  364.     DebugOut("egRequestA");
  365. #endif
  366.  
  367.     lvreq->visualinfo=GetVisualInfo(lvreq->task.screen, TAG_END);
  368.     switch(lvreq->type)
  369.     {
  370.         case EG_ListviewRequest:
  371.             retvalue=egLVRequestA(lvreq, taglist);
  372.             break;
  373.     }
  374.     FreeVisualInfo(lvreq->visualinfo);
  375.  
  376.     return retvalue;
  377. }
  378.  
  379. __asm void egInitialPercent(register __a0 APTR inreq)
  380. {
  381.     register struct ListviewRequester    *req=(struct ListviewRequester *)inreq;
  382.  
  383. #ifdef MYDEBUG_H
  384.     DebugOut("egInitialPercent");
  385. #endif
  386.  
  387.     if(req->percenth)
  388.         req->Width    =req->task.screen->Width/100*req->percenth;
  389.     if(req->percentv)
  390.         req->Height    =req->task.screen->Height/100*req->percentv;
  391.  
  392.     req->percentv=req->percenth=0;
  393. }
  394.  
  395. __asm void egInitialCentre(register __a0 APTR inreq)
  396. {
  397.     register struct ListviewRequester    *req=(struct ListviewRequester *)inreq;
  398.  
  399. #ifdef MYDEBUG_H
  400.     DebugOut("egInitialCentre");
  401. #endif
  402.  
  403.     if(req->centreh)
  404.         req->LeftEdge    =req->task.screen->Width/2-req->Width/2;
  405.     if(req->centrev)
  406.         req->TopEdge    =req->task.screen->Height/2-req->Height/2;
  407.  
  408.     req->centrev=req->centreh=FALSE;
  409. }
  410.  
  411. __asm ULONG egHookEntry(register __a0 struct Hook *hook,
  412.                                                 register __a2 VOID *o,
  413.                                                 register __a1 VOID *msg)
  414. {
  415. #ifdef MYDEBUG_H
  416.     DebugOut("eg_HookEntry");
  417. #endif
  418.     return ((*(ULONG (*)(struct Hook *,VOID *,VOID *))(hook->h_SubEntry))(hook, o, msg));
  419. }
  420.  
  421. __asm VOID egInitHook(register __a0 struct Hook *h,
  422.                                             register __a2 ULONG (*func)(),
  423.                                             register __a1 VOID *data)
  424. {
  425. #ifdef MYDEBUG_H
  426.     DebugOut("egInitHook");
  427. #endif
  428.     if(h)
  429.     {
  430.         h->h_Entry        =(ULONG (*)()) egHookEntry;
  431.         h->h_SubEntry    =func;
  432.         h->h_Data            =data;
  433.     }
  434. }
  435.  
  436. __asm ULONG egCallHook(    register __a0 APTR req,
  437.                                                 register __a1 struct IntuiMessage *msg)
  438. {
  439.     struct Hook    hook;
  440.     ULONG retvalue=1;
  441.  
  442. #ifdef MYDEBUG_H
  443.     DebugOut("egCallHook");
  444. #endif
  445.  
  446.     if(((struct ListviewRequester *)req)->func)
  447.     {
  448.         egInitHook(&hook, ((struct ListviewRequester *)req)->func, msg);
  449.         retvalue=CallHookPkt(&hook, NULL, NULL);
  450.     }
  451.     return retvalue;
  452. }
  453. */
  454. #endif
  455.